/*!
 * \file WtUftRunner.cpp
 * \project	WonderTrader
 *
 * \author Wesley
 * \date 2020/03/30
 * 
 * \brief WonderTrader超高频运行器类实现文件
 *		  本文件实现了WtUftRunner超高频运行器类的所有方法
 *		  提供完整的超高频交易系统生命周期管理功能
 *		  支持UFT引擎的初始化和运行，专门针对超高频交易优化
 *		  集成行情解析、交易适配、策略管理、数据管理等核心组件
 *		  实现微秒级延迟的交易系统运行框架
 */
#include "WtUftRunner.h"

#include "../WtUftCore/WtHelper.h"
#include "../WtUftCore/UftStraContext.h"

#include "../Includes/WTSVariant.hpp"
#include "../WTSTools/WTSLogger.h"
#include "../WTSUtils/WTSCfgLoader.h"
#include "../WTSUtils/SignalHook.hpp"
#include "../Share/StrUtil.hpp"


/**
 * @brief 获取程序二进制文件目录
 * @return 返回程序安装目录路径
 * @details 获取当前程序的安装目录路径
 *          使用boost::filesystem获取初始路径
 *          路径会被标准化处理，确保跨平台兼容性
 *          结果会被缓存，避免重复计算
 */
const char* getBinDir()
{
	static std::string basePath;
	if (basePath.empty())
	{
		basePath = boost::filesystem::initial_path<boost::filesystem::path>().string();

		basePath = StrUtil::standardisePath(basePath);
	}

	return basePath.c_str();
}



/**
 * @brief 构造函数
 * @details 初始化WtUftRunner实例，设置默认状态
 *          注：UFT模式下信号处理被注释掉，以减少延迟
 *          在超高频交易中，任何额外的处理都可能影响性能
 *          因此禁用了信号钩子以获得最佳性能
 */
WtUftRunner::WtUftRunner()
{
//#if _WIN32
//#pragma message("Signal hooks disabled in WIN32")
//#else
//#pragma message("Signal hooks enabled in UNIX")
//	install_signal_hooks([](const char* message) {
//		WTSLogger::error(message);
//	});
//#endif
}


/**
 * @brief 析构函数
 * @details 清理WtUftRunner资源
 *          释放相关内存和资源
 *          各个组件会在其析构函数中自动清理
 */
WtUftRunner::~WtUftRunner()
{
}

/**
 * @brief 初始化系统
 * @return 成功返回true，失败返回false
 * @details 执行系统基础初始化操作：
 *          1. 初始化日志系统
 *             - 优先加载logcfg.json配置文件
 *             - 如果不存在则尝试logcfg.yaml
 *          2. 设置程序安装目录
 *             - 通过WtHelper设置全局安装目录
 *             - 用于后续模块路径解析
 */
bool WtUftRunner::init()
{
	std::string path = "logcfg.json";
	if(!StdFile::exists(path.c_str()))
		path = "logcfg.yaml";
	WTSLogger::init(path.c_str());

	WtHelper::setInstDir(getBinDir());

	return true;
}

/**
 * @brief 配置系统
 * @return 成功返回true，失败返回false
 * @details 加载和配置系统各个组件，执行以下步骤：
 *          1. 加载主配置文件（config.json/yaml）
 *          2. 加载基础数据文件（交易时段、品种、合约、节假日等）
 *          3. 初始化UFT引擎
 *          4. 初始化数据管理器
 *          5. 初始化动作策略管理器
 *          6. 初始化行情解析器（支持配置文件或数组配置）
 *          7. 初始化交易适配器（支持配置文件或数组配置）
 *          8. 初始化UFT策略
 */
bool WtUftRunner::config()
{
	std::string cfgFile = "config.json";
	if (!StdFile::exists(cfgFile.c_str()))
		cfgFile = "config.yaml";

	_config = WTSCfgLoader::load_from_file(cfgFile, true);
	if(_config == NULL)
	{
		WTSLogger::error_f("Loading config file {} failed", cfgFile);
		return false;
	}

	// 加载基础数据文件
	WTSVariant* cfgBF = _config->get("basefiles");
	bool isUTF8 = cfgBF->getBoolean("utf-8");
	if (cfgBF->get("session"))
		_bd_mgr.loadSessions(cfgBF->getCString("session"), isUTF8);

	WTSVariant* cfgItem = cfgBF->get("commodity");
	if (cfgItem)
	{
		if (cfgItem->type() == WTSVariant::VT_String)
		{
			_bd_mgr.loadCommodities(cfgItem->asCString(), isUTF8);
		}
		else if (cfgItem->type() == WTSVariant::VT_Array)
		{
			for (uint32_t i = 0; i < cfgItem->size(); i++)
			{
				_bd_mgr.loadCommodities(cfgItem->get(i)->asCString(), isUTF8);
			}
		}
	}

	cfgItem = cfgBF->get("contract");
	if (cfgItem)
	{
		if (cfgItem->type() == WTSVariant::VT_String)
		{
			_bd_mgr.loadContracts(cfgItem->asCString(), isUTF8);
		}
		else if (cfgItem->type() == WTSVariant::VT_Array)
		{
			for (uint32_t i = 0; i < cfgItem->size(); i++)
			{
				_bd_mgr.loadContracts(cfgItem->get(i)->asCString(), isUTF8);
			}
		}
	}

	if (cfgBF->get("holiday"))
		_bd_mgr.loadHolidays(cfgBF->getCString("holiday"));


	// 初始化交易引擎
	initEngine();

	// 初始化数据管理器
	initDataMgr();

	if(!_act_policy.init(_config->getCString("bspolicy")))
	{
		WTSLogger::error_f("ActionPolicyMgr init failed, please check config");
	}

	// 初始化行情通道
	WTSVariant* cfgParser = _config->get("parsers");
	if (cfgParser)
	{
		if (cfgParser->type() == WTSVariant::VT_String)
		{
			const char* filename = cfgParser->asCString();
			if (StdFile::exists(filename))
			{
				WTSLogger::info_f("Reading parser config from {}...", filename);
				WTSVariant* var = WTSCfgLoader::load_from_file(filename, isUTF8);
				if(var)
				{
					if (!initParsers(var->get("parsers")))
						WTSLogger::error("Loading parsers failed");
					var->release();
				}
				else
				{
					WTSLogger::error_f("Loading parser config {} failed", filename);
				}
			}
			else
			{
				WTSLogger::error_f("Parser configuration {} not exists", filename);
			}
		}
		else if (cfgParser->type() == WTSVariant::VT_Array)
		{
			initParsers(cfgParser);
		}
	}

	// 初始化交易通道
	WTSVariant* cfgTraders = _config->get("traders");
	if (cfgTraders)
	{
		if (cfgTraders->type() == WTSVariant::VT_String)
		{
			const char* filename = cfgTraders->asCString();
			if (StdFile::exists(filename))
			{
				WTSLogger::info_f("Reading trader config from {}...", filename);
				WTSVariant* var = WTSCfgLoader::load_from_file(filename, isUTF8);
				if (var)
				{
					if (!initTraders(var->get("traders")))
						WTSLogger::error("Loading traders failed");
					var->release();
				}
				else
				{
					WTSLogger::error_f("Loading trader config {} failed", filename);
				}
			}
			else
			{
				WTSLogger::error("Trader configuration %s not exists", filename);
			}
		}
		else if (cfgTraders->type() == WTSVariant::VT_Array)
		{
			initTraders(cfgTraders);
		}
	}

	initUftStrategies();
	
	return true;
}

/**
 * @brief 初始化UFT引擎
 * @return 成功返回true，失败返回false
 * @details 初始化超高频交易引擎：
 *          1. 从环境配置中获取引擎配置
 *          2. 使用配置初始化UFT引擎
 *          3. 绑定基础数据管理器、数据管理器、主力合约管理器
 *          4. 设置交易适配器管理器
 *          
 *          UFT引擎专门针对超高频交易优化：
 *          - 支持微秒级延迟
 *          - 优化内存分配
 *          - 减少系统调用
 */
bool WtUftRunner::initEngine()
{
	WTSVariant* cfg = _config->get("env");
	if (cfg == NULL)
		return false;

	_uft_engine.init(cfg, &_bd_mgr, &_data_mgr);
	_uft_engine.set_adapter_mgr(&_traders);

	return true;
}

/**
 * @brief 初始化数据管理器
 * @return 成功返回true，失败返回false
 * @details 初始化UFT数据管理器：
 *          1. 从配置中获取数据配置
 *          2. 使用配置和引擎初始化数据管理器
 *          3. 记录初始化完成日志
 *          
 *          UFT数据管理器特点：
 *          - 优化内存使用
 *          - 快速数据访问
 *          - 支持Level2数据
 */
bool WtUftRunner::initDataMgr()
{
	WTSVariant*cfg = _config->get("data");
	if (cfg == NULL)
		return false;

	_data_mgr.init(cfg, &_uft_engine);
	WTSLogger::info("Data manager initialized");

	return true;
}

/**
 * @brief 初始化行情解析器
 * @param cfgParser 行情解析器配置数组
 * @return 成功返回true，失败返回false
 * @details 根据配置初始化所有行情解析器：
 *          1. 遍历配置数组中的每个解析器配置
 *          2. 跳过非活跃的解析器
 *          3. 为每个解析器：
 *             - 获取或生成解析器ID
 *             - 创建解析器适配器
 *             - 初始化适配器（针对UFT优化）
 *             - 添加到解析器管理器
 *          4. 记录加载的解析器数量
 *          
 *          UFT模式下的行情解析器特点：
 *          - 支持Level2深度数据
 *          - 微秒级数据处理
 *          - 零拷贝数据传输
 */
bool WtUftRunner::initParsers(WTSVariant* cfgParser)
{
	if (cfgParser == NULL)
		return false;

	uint32_t count = 0;
	for (uint32_t idx = 0; idx < cfgParser->size(); idx++)
	{
		WTSVariant* cfgItem = cfgParser->get(idx);
		if(!cfgItem->getBoolean("active"))
			continue;

		const char* id = cfgItem->getCString("id");
		// By Wesley @ 2021.12.14
		// 如果id为空，则自动生成id
		std::string realid = id;
		if (realid.empty())
		{
			static uint32_t auto_parserid = 1000;
			realid = StrUtil::printf("auto_parser_%u", auto_parserid++);
		}

		ParserAdapterPtr adapter(new ParserAdapter);
		adapter->init(realid.c_str(), cfgItem, &_uft_engine, &_bd_mgr);
		_parsers.addAdapter(realid.c_str(), adapter);

		count++;
	}

	WTSLogger::info("%u parsers loaded", count);
	return true;
}

/**
 * @brief 初始化交易适配器
 * @param cfgTrader 交易适配器配置数组
 * @return 成功返回true，失败返回false
 * @details 根据配置初始化所有交易适配器：
 *          1. 遍历配置数组中的每个交易适配器配置
 *          2. 跳过非活跃的适配器
 *          3. 为每个适配器：
 *             - 创建交易适配器实例
 *             - 初始化适配器（绑定基础数据管理器、动作策略）
 *             - 添加到交易适配器管理器
 *          4. 记录加载的适配器数量
 *          
 *          UFT模式下的交易适配器特点：
 *          - 极低延迟订单处理
 *          - 优化的网络通信
 *          - 快速订单状态更新
 */
bool WtUftRunner::initTraders(WTSVariant* cfgTrader)
{
	if (cfgTrader == NULL || cfgTrader->type() != WTSVariant::VT_Array)
		return false;
	
	uint32_t count = 0;
	for (uint32_t idx = 0; idx < cfgTrader->size(); idx++)
	{
		WTSVariant* cfgItem = cfgTrader->get(idx);
		if (!cfgItem->getBoolean("active"))
			continue;

		const char* id = cfgItem->getCString("id");

		TraderAdapterPtr adapter(new TraderAdapter);
		adapter->init(id, cfgItem, &_bd_mgr, &_act_policy);

		_traders.addAdapter(id, adapter);

		count++;
	}

	WTSLogger::info("%u traders loaded", count);

	return true;
}

/**
 * @brief 初始化UFT策略
 * @return 成功返回true，失败返回false
 * @details 加载和初始化所有UFT策略：
 *          1. 从配置中获取UFT策略配置数组
 *          2. 从uft/目录加载策略工厂
 *          3. 遍历配置，为每个活跃策略：
 *             - 创建策略实例
 *             - 初始化策略参数
 *             - 创建策略上下文
 *             - 绑定策略到上下文
 *             - 绑定交易适配器到上下文
 *             - 添加上下文到UFT引擎
 *          
 *          UFT策略特点：
 *          - 微秒级策略执行
 *          - 支持Level2数据
 *          - 极速订单处理
 *          - 内存优化设计
 */
bool WtUftRunner::initUftStrategies()
{
	WTSVariant* cfg = _config->get("strategies");
	if (cfg == NULL || cfg->type() != WTSVariant::VT_Object)
		return false;

	cfg = cfg->get("uft");
	if (cfg == NULL || cfg->type() != WTSVariant::VT_Array)
		return false;

	std::string path = WtHelper::getCWD() + "uft/";
	_uft_stra_mgr.loadFactories(path.c_str());

	for (uint32_t idx = 0; idx < cfg->size(); idx++)
	{
		WTSVariant* cfgItem = cfg->get(idx);
		if (!cfgItem->getBoolean("active"))
			continue;

		const char* id = cfgItem->getCString("id");
		const char* name = cfgItem->getCString("name");
		UftStrategyPtr stra = _uft_stra_mgr.createStrategy(name, id);
		if (stra == NULL)
			continue;

		stra->self()->init(cfgItem->get("params"));
		UftStraContext* ctx = new UftStraContext(&_uft_engine, id);
		ctx->set_strategy(stra->self());

		const char* traderid = cfgItem->getCString("trader");
		TraderAdapterPtr trader = _traders.getAdapter(traderid);
		if(trader)
		{
			ctx->setTrader(trader.get());
			trader->addSink(ctx);
		}
		else
		{
			WTSLogger::error("Trader %s not exists, binding trader to UFT strategy failed", traderid);
		}

		_uft_engine.addContext(UftContextPtr(ctx));
	}

	return true;
}

/**
 * @brief 运行系统
 * @param bAsync 是否异步运行，默认为false
 * @details 启动整个超高频交易系统：
 *          1. 启动行情解析器管理器
 *          2. 启动交易适配器管理器
 *          3. 启动UFT引擎
 *          
 *          使用异常处理确保系统稳定性
 *          如果bAsync为true，则异步运行；否则阻塞运行
 *          
 *          UFT模式下的运行特点：
 *          - 极低延迟启动
 *          - 优化的事件循环
 *          - 最小化系统开销
 */
void WtUftRunner::run(bool bAsync /* = false */)
{
	try
	{
		_parsers.run();
		_traders.run();

		_uft_engine.run(bAsync);
	}
	catch (...)
	{
		//print_stack_trace([](const char* message) {
		//	WTSLogger::error(message);
		//});
	}
}

/// 日志级别标签数组，用于日志级别到字符串的转换
const char* LOG_TAGS[] = {
	"all",
	"debug",
	"info",
	"warn",
	"error",
	"fatal",
	"none"
};

/**
 * @brief 处理日志追加
 * @param ll 日志级别
 * @param msg 日志消息
 * @details 实现ILogHandler接口，处理系统日志
 *          在超高频模式下，日志处理也需要优化性能
 *          避免在关键路径上进行复杂的日志操作
 *          
 *          注：当前实现为空，可能是为了减少UFT模式下的延迟
 *              在生产环境中可能需要实现高性能的日志处理
 */
void WtUftRunner::handleLogAppend(WTSLogLevel ll, const char* msg)
{
}